#include "Board.h"

/* Constructeur
**
** Initialise le plateau pour une nouvelle partie.
*/
Board::Board()
{
//    initialization();
	emptyBoard();
}



/* Initialise l'othellier pour une nouvelle partie
**
** Le plateau est d'abord vidé des pions qu'il peut contenir et ensuite on
** dispose les 4 pions de départ ainsi que les 4 coups légaux du premier
** joueur.
** Enfin on signale que le plateau a été modofié.
*/
void Board::initialization()
{
    //Vide le plateau entièrement
    emptyBoard();

    //Ajoute les 4 pions de départ
    boardTable[3][3].setSquare(Occupied,White);
    boardTable[4][4].setSquare(Occupied,White);
    boardTable[4][3].setSquare(Occupied,Black);
    boardTable[3][4].setSquare(Occupied,Black);

    //Ajoute les 4 coups légaux du premier joueur
    boardTable[3][2].setType(RegularMove);
    boardTable[2][3].setType(RegularMove);
    boardTable[5][4].setType(RegularMove);
    boardTable[4][5].setType(RegularMove);
}



/* Ajout d'un pion de couleur 'color' dans la case [x][y] de l'othellier.
**
** Un pion ne peut être posé que sur une case contenant un coup légal.
** Le pion posé devient le dernier coup joué sur l'othellier.
** Les coups légaux sont supprimés du plateau.
** On affecte à la case [x][y] les valeurs 'Occupied' et 'color'.
** On signale que l'othellier a été modifié.
**
** La fonction retourne 'true' si le pion a été ajouté au plateau, 'false' sinon.
*/
bool Board::addPawn(int x, int y, ColorPawn color)
{
    //Valeur de retour
    bool ret = false;

    //Vérification des coordonnées pour ne pas sortir du tableau
    if( x>=0 && y>=0 && x<8 && y<8 )
    {
        //Test si la case est un coup légal
        if( boardTable[x][y].getType() == RegularMove )
        {
            //Efface le dernier coup joué
            clearLastMove();
            //Efface les coups légaux du plateau
            clearRegularMove();
            //Ajoute le pion sur le plateau
            boardTable[x][y].setSquare(Occupied,color);
            //Activation de l'indicateur 'LastMove'
            boardTable[x][y].setLastMove(true);
            //Valeur de retour MAJ
            ret = true;
        }
    }
    return ret;
}



/* Retourne le pion contenu dans la case [x][y] du plateau.
**
** La case [x][y] doit contenir un pion.
** La couleur du pion est inversée et l'indicateur 'animated' est activé.
** On signale que l'othellier a été modifié.
*/
bool Board::turnDownPawn(int x, int y)
{
	//Valeur de retour
	bool ret = false;
    //Vérification des coordonnées pour ne pas sortir du tableau
    if( x>=0 && y>=0 && x<8 && y<8 )
    {
        //Test si la case contient un pion
        if( boardTable[x][y].getType() == Occupied )
        {
            //Change la couleur du pion
            if( boardTable[x][y].getColor() == White )
            {
                boardTable[x][y].setColor(Black);
            }
            else
            {
                boardTable[x][y].setColor(White);
            }
            //Mise en animation de la case
            boardTable[x][y].setAnimated(true);
            //Indique que la board contient des cases en animation
            setAnimated(true);
            //Valeur de retour MAJ
            ret = true;
        }
    }
    return ret;
}



/* Ajout d'un coup légal dans la case [x][y] de l'othellier.
**
** Pour ajouter un coup légal, la case doit être vide.
** On affecte à la case [x][y] la valeur 'RegularMove'.
*/
bool Board::addRegularMove(int x, int y)
{
	//Valeur de retour
	bool ret = false;
    //Vérification des coordonnées pour ne pas sortir du tableau
    if( x>=0 && y>=0 && x<8 && y<8 )
    {
        //Test si la case est vide
        if( boardTable[x][y].getType() == Empty )
        {
            //Ajout du coup légal
            boardTable[x][y].setType(RegularMove);
            ret = true;
        }
    }
    return ret;
}



/* Supprime les animations du plateau
** et des cases du plateau
*/
void Board::clearAnimation()
{
	setAnimated( false );
    for( int y=0 ; y<8 ; y++ )
    {
        for( int x=0 ; x<8 ; x++ )
        {
           	boardTable[x][y].setAnimated( false );
        }
    }
}



/* Mutateur de la variable 'animated'
*/
void Board::setAnimated(bool b)
{
	animated = b;
}



/* Accesseur de la variable 'animated'
*/
bool Board::getAnimated()
{
	return animated;
}



/* Accesseur qui retourne le type de la case [x][y] de l'othellier.
**
** On vérifie les coordonnées transmises à la fonction puis on renvoie la valeur
** du type de la case grâce à son accesseur public.
*/
TypeSquare Board::getTypeSquareBoard(int x, int y)
{
    if( x>=0 && y>=0 && x<8 && y<8 )
    {
        return boardTable[x][y].getType();
    }
}



/* Accesseur qui retourne la couleur du pion contenu dans la case [x][y] de
** l'othellier.
**
** On vérifie les coordonnées transmises à la fonction puis on renvoie la valeur
** de la couleur du pion grâce à son accesseur public.
*/
ColorPawn Board::getColorPawnBoard(int x, int y)
{
    if( x>=0 && y>=0 && x<8 && y<8 )
    {
        return boardTable[x][y].getColor();
    }
}



/*
*/
bool Board::getAnimatedSquare(int x, int y)
{
    if( x>=0 && y>=0 && x<8 && y<8 )
    {
        return boardTable[x][y].getAnimated();
    }
}



/*
*/
bool Board::getLastMoveSquare(int x, int y)
{
    if( x>=0 && y>=0 && x<8 && y<8 )
    {
        return boardTable[x][y].getLastMove();
    }
}



/* Vide l'othellier de tous les pions qu'il contient.
**
** Parcours toutes les cases du plateau et initialise le 'type' de la case à la
** valeur 'Empty'.
*/
void Board::emptyBoard()
{
    for( int x=0 ; x<8 ; x++ )
    {
        for( int y=0 ; y<8 ; y++ )
        {
            boardTable[x][y].setType(Empty);
        }
    }
}



/* Suppression des coups légaux de l'othellier.
**
** On parcours toutes les cases de l'othellier.
** Si la case courante contient un coup légal, on vide la case en lui affectant
** la valeur 'Empty'.
*/
void Board::clearRegularMove()
{
    for( int x=0 ; x<8 ; x++ )
    {
        for( int y=0 ; y<8 ; y++ )
        {
            if( boardTable[x][y].getType() == RegularMove )
            {
                boardTable[x][y].setType(Empty);
            }
        }
    }
}



/* Suppression du dernier coup joué sur l'othellier.
**
** Parcours toutes les cases de l'othellier.
** Si la case courante contient le dernier coup joué, on désactive l'indicateur,
** et on interrompt les boucles de parcours.
*/
void Board::clearLastMove()
{
    for( int y=0 ; y<8 ; y++ )
    {
        for( int x=0 ; x<8 ; x++ )
        {
        	if( boardTable[x][y].getLastMove() == true )
        	{
            	boardTable[x][y].setLastMove(false);
            	x=8;  y=8;  //interruption des boucles de parcours
        	}
        }
    }
}

void Board::emptySquare(int x, int y)
{
	boardTable[x][y].setType(Empty);
	boardTable[x][y].setLastMove(false);
}


void Board::enableLastMoveSquare(int x, int y)
{
	boardTable[x][y].setLastMove(true);
}
